package inteface;

import inteface.MostrarPeliculas.TablaPeliculasModel;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Map;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.InternalFrameListener;
import javax.swing.table.AbstractTableModel;

import domain.CD;
import domain.GestorProductos;
import domain.GestorUsuario;
import domain.Pelicula;
import domain.Usuario;

public class MostrarClientes extends JInternalFrame implements ActionListener,
		InternalFrameListener {

	/**
* 
*/
	private static final long serialVersionUID = 1L;

	private Principal parent;
	private static JTable tbClientes;

	private JButton jbEliminar;
	private JButton jbCancelar;
	private JButton jbCerrar;
	private String accion;

	static Map<String, Usuario> usuario;
	// Create the scroll pane and add the table to it.
	JScrollPane scrollPane;
	JPanel jpBotones;

	public MostrarClientes(Principal padre) {

		super("Lista de Clientes", true, // resizable
				false, // closable
				false, // maximizable
				false);// iconifiable
		setVisible(true);
		setSize(800, 300);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.inicializarSubComponentes();

		parent = padre;

	}

	private void inicializarSubComponentes() {

		try {

			scrollPane = new JScrollPane(tbClientes);

			this.getContentPane().setLayout(new BorderLayout());
			this.getContentPane().add(scrollPane, "Center");

			jbEliminar = new JButton("Eliminar");
			jbCancelar = new JButton("Cancelar");
			jbCerrar = new JButton("Cerrar");
			jbEliminar.addActionListener(this);
			jbCancelar.addActionListener(this);
			jbCerrar.addActionListener(this);

			jpBotones = new JPanel();
			jpBotones.setLayout(new FlowLayout());

			if (accion.equals("Mostrar"))
				jpBotones.add(jbCerrar);
			else if (accion.equals("Eliminar")) {
				jpBotones.add(jbEliminar);
				jpBotones.add(jbCancelar);
			}

			this.getContentPane().add(jpBotones, "South");
		} catch (Exception e) {

		}

	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() instanceof JButton) {
			JButton btnPulsado = (JButton) e.getSource();
			if (btnPulsado == jbEliminar) {

				Integer valor;
				int selectedRow = tbClientes.getSelectedRow();
				if (selectedRow == -1) {
					String aviso = "Debes seleccionar una fila dela tabla";
					JOptionPane.showMessageDialog(this, aviso);
				} else {
					valor = (Integer) tbClientes.getValueAt(
							tbClientes.getSelectedRow(), 0);

					try {
						eliminarUsuario(valor);
						dispose();
					} catch (Exception ex) {

					}
				}
			} else if (btnPulsado == jbCancelar) {
				dispose();
			} else if (btnPulsado == jbCerrar) {
				dispose();
			}
		}

	}

	public boolean blnCargarFormulario(int xpos, int ypos, String accion) {
		boolean blnResultado = true;
		this.accion = accion;
		GestorUsuario gestorUsuario = new GestorUsuario();
		usuario = gestorUsuario.consultarUsuarios();
		if (usuario != null) {
			crearTablaUsuarios();
		}

		this.setLocation(xpos, ypos);
		this.setVisible(true);
		inicializarSubComponentes();

		return blnResultado;
	}

	private void crearTablaUsuarios() {

		tbClientes = null;
		TablaUsuariosModel tum = new TablaUsuariosModel(usuario);
		tbClientes = new JTable(tum);
		tbClientes.setPreferredScrollableViewportSize(new Dimension(500, 70));
		tbClientes.setFillsViewportHeight(true);
		tbClientes.setEnabled(true);
		tbClientes.setRowSelectionAllowed(true);
		tum.fireTableDataChanged();

	}

	public static void refreshTable() {
		TablaUsuariosModel tum = (TablaUsuariosModel) tbClientes.getModel();
		tum.setData(usuario);
		tum.fireTableDataChanged();
	}

	private void eliminarUsuario(Integer key) {

		GestorUsuario gestorUsuario = new GestorUsuario();

		Object keyElegida = buscarEnArray(usuario.keySet().toArray(),
				String.valueOf(key));
		usuario.remove(keyElegida);

		gestorUsuario.eliminarUsuario();
		if (usuario != null) {

			Object[] keyNuevas = usuario.keySet().toArray();
			for (int i = 0; i < usuario.size(); i++) {
				Object keyNueva = keyNuevas[i];
				String nombre = usuario.get(keyNueva).getNombre();
				String apellido = usuario.get(keyNueva).getApellido();
				String dni = usuario.get(keyNueva).getDni();
				String fechaNacimiento = usuario.get(keyNueva)
						.getFechaNacimiento();
				int telefono = usuario.get(keyNueva).getTelefono();
				String username = usuario.get(keyNueva).getUsername();
				String password = usuario.get(keyNueva).getPassword();
				double saldo = usuario.get(keyNueva).getSaldo();

				gestorUsuario.nuevoUsuarioTrasEliminar(
						Integer.valueOf(keyNueva.toString()), nombre, apellido,
						dni, fechaNacimiento, telefono, username, password,
						saldo);
			}

		}

		this.refreshTable();
		JOptionPane.showMessageDialog(this, "Cliente eliminado");

	}

	public Object buscarEnArray(Object[] array, String id) {
		Object result = null;
		boolean encontrado = false;
		int i = 0;
		while (i < array.length && encontrado == false) {
			if (id.equals(array[i].toString())) {
				encontrado = true;
				result = array[i];
			}
			i++;
		}
		return result;
	}

	class TablaUsuariosModel extends AbstractTableModel {
		private static final long serialVersionUID = 1L;

		private String[] columnNames = { "ID", "Nombre", "Apellido", "DNI",
				"Telefono", "Fecha de nacimiento", "Nombre de usuario", "Saldo" };
		Object[][] data;

		public TablaUsuariosModel(Map<String, Usuario> m) {

			super();

			int filas = m.size();
			int cont;
			data = new Object[filas][];
			cont = 0;

			for (Map.Entry<String, Usuario> entry : m.entrySet()) {

				Object[] a = { new Integer(entry.getKey()),
						new String(entry.getValue().getNombre()),
						new String(entry.getValue().getApellido()),
						new String(entry.getValue().getDni()),
						new Integer(entry.getValue().getTelefono()),
						new String(entry.getValue().getFechaNacimiento()),
						new String(entry.getValue().getUsername()),
						new Double(entry.getValue().getSaldo()) };

				data[cont] = a;
				cont++;
			}

		}

		public void setData(Map<String, Usuario> m) {
			int filas = m.size();
			int cont;
			data = new Object[filas][];
			cont = 0;

			for (Map.Entry<String, Usuario> entry : m.entrySet()) {

				Object[] a = { new Integer(entry.getKey()),
						new String(entry.getValue().getNombre()),
						new String(entry.getValue().getApellido()),
						new Integer(entry.getValue().getDni()),
						new Integer(entry.getValue().getTelefono()),
						new String(entry.getValue().getFechaNacimiento()),
						new String(entry.getValue().getUsername()),
						new Double(entry.getValue().getSaldo()) };
				data[cont] = a;
				cont++;
			}
		}

		public int getColumnCount() {
			return columnNames.length;
		}

		public int getRowCount() {
			return data.length;
		}

		public String getColumnName(int col) {
			return columnNames[col];
		}

		public Object getValueAt(int row, int col) {
			return data[row][col];
		}

		public Class getColumnClass(int c) {
			return getValueAt(0, c).getClass();
		}

		public boolean isCellEditable(int row, int col) {

			return false;

		}

		public void setValueAt(Object value, int row, int col) {

			data[row][col] = value;
			fireTableCellUpdated(row, col);

		}

		private void printDebugData() {
			int numRows = getRowCount();
			int numCols = getColumnCount();

			for (int i = 0; i < numRows; i++) {
				for (int j = 0; j < numCols; j++) {

				}

			}
		}
	}

	@Override
	public void internalFrameActivated(InternalFrameEvent arg0) {
		// TODO Auto-generated method stub

	}

	@Override
	public void internalFrameClosed(InternalFrameEvent arg0) {

		if (arg0.getSource() instanceof MostrarPeliculas) {
			MostrarPeliculas j = (MostrarPeliculas) arg0.getSource();

			this.refreshTable();
		}

	}

	@Override
	public void internalFrameClosing(InternalFrameEvent arg0) {

	}

	@Override
	public void internalFrameDeactivated(InternalFrameEvent arg0) {
		// TODO Auto-generated method stub

	}

	@Override
	public void internalFrameDeiconified(InternalFrameEvent arg0) {
		// TODO Auto-generated method stub

	}

	@Override
	public void internalFrameIconified(InternalFrameEvent arg0) {
		// TODO Auto-generated method stub

	}

	@Override
	public void internalFrameOpened(InternalFrameEvent arg0) {
		// TODO Auto-generated method stub

	}

}
